Developer CD Series 1995 August: Tool Chest/Dev.CD Aug 95 TC/Dev.CD Aug 95 TC.toast/Sample Code/DTS QT Utilities.May-95/Projects & Test Apps/QT Internals/QTInternals.c

Text File | 1995-04-30 | 13.2 KB | 399 lines | [TEXT/MPCC]

/*
    File:        QTInternals.c

    Contains:    Functions dealing with dumping internal movie information.

    Written by:    DTS

    Copyright:    © 1995 by Apple Computer, Inc., all rights reserved.

    Change History (most recent first):

       <1>         1/4/95    khs        first file

*/


// INCLUDES
#include "QTInternals.h"
#include "DTSQTUtilities.h"


// ______________________________________________________________________
// FUNCTIONS



// ______________________________________________________________________
void ShowGlobalMovieInfo(Movie theMovie)
{
    Str255     tmpStr;
    TimeValue    tv, ts;
    Fixed mr;

    DebugAssert(aMovie != NULL);

    GetWTitle(FrontWindow(), tmpStr);
    printf("\nGlobal System Information for %s:\n", p2cstr(tmpStr));

    // Memory related information.
    printf("This movie allocates %ld bytes in the current application heap.\n",
        QTUCalculateMovieMemorySize(theMovie));
    printf("Note that any possible associated movie controllers take each 10k or so.\n\n");

    // Global Time Information
    ts = GetMovieTimeScale(theMovie);
    tv = GetMovieDuration(theMovie);
    printf("The time scale for this movie is %ld.\n", ts);
    printf("The movie duration (TimeValue) = %ld\n", tv);
    printf("The movie duration in seconds = %7.2f\n", (float)  tv / ts);

    printf("The current movie position (in seconds) = %7.2f\n", (float) GetMovieTime(theMovie, NULL) / ts);

    mr = GetMovieRate(theMovie);
    printf("The current movie rate is %7.2f  (0 means movie is not running, < 0 going backwards).\n",  (float) mr /fixed1);
}


// ______________________________________________________________________
void ShowMovieTrackInfo(Movie theMovie)
{
    OSErr                    anErr  = noErr;
    long                        aTrackCount, index;
    Track                    aTrack;
    long                        aTrackUsage;
    Str255                    tmpStr;
    Fixed                    height, width;
    short                    trackVol;
    MatrixRecord        mr;
    long                        nVideoTracks = 0;
    long                        nSoundTracks = 0;
    long                        nTextTracks = 0;
    long                        nMusicTracks = 0;

    GetWTitle(FrontWindow(), tmpStr);
    printf("\nTrack Information for %s:\n", p2cstr(tmpStr));

    // TRACK COUNT
    aTrackCount = GetMovieTrackCount(theMovie);
    anErr = GetMoviesError(); DebugAssert(anErr == noErr);
    if(anErr != noErr) return;

    if(aTrackCount == 0)
    {
        printf("The Movie has no tracks.\n");
        return;
    }
    else
        printf("The Movie has %d track(s).\n", aTrackCount);

    // Parse through each track and get more information:
    for(index = 1; index <= aTrackCount; index++)
    {
        OSType aTrackType;
        Media aMedia;

        printf("\n");

        aTrack = GetMovieIndTrack(theMovie, index);

        // TRACK TYPE
        aMedia = GetTrackMedia(aTrack);
        GetMediaHandlerDescription(aMedia, &aTrackType, 0, 0);

        switch (aTrackType)
        {
            case SoundMediaType: printf("This is a sound track.\n");
                nSoundTracks++;
                break;

            case VideoMediaType: printf("This is a video track.\n");
                nVideoTracks++;
                break;

            case TextMediaType: printf("This is a text track.\n");
                nTextTracks++;
                break;

            case MPEGMediaType: printf("This is an MPEG track.\n");
                break;

            case MusicMediaType: printf("This is a music track.\n");
                nMusicTracks++;
                break;

            case TimeCodeMediaType: printf("This is a time code track.\n");
                break;

            default:
            {
                Byte *bp = (Byte *)&aTrackType;
                printf("The track is of type '%c%c%c%c' format.\n", bp[0], bp[1], bp[2], bp[3]);
                break;
            }
        }

        // TRACK ID
        printf("Track ID: %d\n", GetTrackID(aTrack));

        // TRACK ENABLED
        if(GetTrackEnabled(aTrack))
            printf("Track is enabled.\n");
        else
            printf("Track is disabled.\n");

        // TRACK LAYER
        printf("Track Layer: %d\n", GetTrackLayer(aTrack));

        // TRACK USAGE
        aTrackUsage = GetTrackUsage(aTrack);
        if(aTrackUsage & trackUsageInMovie)
            printf("Track is used in Movie.\n");
        if(aTrackUsage & trackUsageInPreview)
            printf("Track is used in a preview.\n");
        if(aTrackUsage & trackUsageInPoster)
            printf("Track is used in a poster.\n");

        // TRACK DURATION
        printf("Duration of the track = %ld\n", GetTrackDuration(aTrack));

        // TRACK DIMENSIONS
        GetTrackDimensions(aTrack, &width, &height);
        printf("Track width = %ld, Track height = %ld\n", Fix2Long(width), Fix2Long(height));

        // TRACK MATRIX
        GetTrackMatrix(aTrack, &mr);

        printf("Matrix record, row 0 = [%ld], [%ld], [%ld]\n", Fix2Long(*mr.matrix[0,0]),
                                Fix2Long(*mr.matrix[0,1]), Fix2Long(*mr.matrix[0,2]));
        printf("Matrix record, row 1 = [%ld], [%ld], [%ld]\n", Fix2Long(*mr.matrix[1,0]),
                                Fix2Long(*mr.matrix[1,1]), Fix2Long(*mr.matrix[1,2]));
        printf("Matrix record, row 2 = [%ld], [%ld], [%ld]\n", Fix2Long(*mr.matrix[2,0]),
                                Fix2Long(*mr.matrix[2,1]), Fix2Long(*mr.matrix[2,2]));

        // TRACK VOLUME
        trackVol = GetTrackVolume(aTrack);
        if(trackVol == 255)
            printf("Track Volume is 1.0\n");
        else
            printf("Track Volume = %d.%d\n", (signed short)(trackVol >> 8) , (trackVol & 0xFF));
    }

    // Check how many similar tracks, if too many of same warn (crossplatform issues)
    if(nVideoTracks > 1)
        printf("NOTE! You have more than one video track (%ld tracks), this will be a problem with QuickTime for Windows.\n", nVideoTracks);

    if(nSoundTracks > 1)
        printf("NOTE! You have more than one sound track (%ld tracks), you need to enable just one at a time under QuickTime for Windows (2.0.1 forward).\n", nSoundTracks);

    if(nTextTracks > 1)
        printf("NOTE! You have more than one text track (%ld tracks), this will be a problem with QuickTime for Windows.\n", nTextTracks);

    if(nMusicTracks > 1)
        printf("NOTE! You have more than one music track (%ld tracks), this will be a problem with QuickTime for Windows.\n", nMusicTracks);
}


// ______________________________________________________________________
void ShowMovieVideoInfo(Movie theMovie)
{
    OSErr        anErr = noErr;
    Str255     tmpStr;
    short        trackCount, index;
    long            nSamples;
    float            nSeconds;

    DebugAssert(aMovie != NULL);

    GetWTitle(FrontWindow(), tmpStr);
    printf("\nVideo Media Information for %s:\n", p2cstr(tmpStr));

    // VIDEO FRAMES/SAMPLES
    nSamples = QTUCountMediaSamples(theMovie, VideoMediaType);
    printf("The movie has %ld video frames (samples) ", nSamples);
    printf("of which %ld are key frames\n", QTUCountKeySamples(theMovie, VideoMediaType) );

    printf("The duration of the first video sample is %ld\n", QTUGetDurationOfFirstMovieSample(theMovie, VideoMediaType));

    nSeconds =     GetMovieDuration(theMovie)/ GetMovieTimeScale(theMovie);
    printf("Frames per second (assuming that each video sample is of the same length) = %7.2f  fps\n", (float) nSamples/nSeconds );

    // Get the Image Description Structure and present the values.
    trackCount = GetMovieTrackCount(theMovie);

    for(index = 1; index <= trackCount; index++)
    {
        Track        aTrack = NULL;
        Media        aMedia = NULL;
        OSType        aMediaType;

        aTrack = GetMovieIndTrack(theMovie, index); DebugAssert(aTrack != NULL);
        aMedia = GetTrackMedia(aTrack); DebugAssert(aMedia != NULL);
        anErr = GetMoviesError(); DebugAssert(anErr == noErr);
        if(anErr != noErr)
        {
            printf("Problems with getting trackmedia = %d\n", anErr);
            return;
        }

        GetMediaHandlerDescription(aMedia, &aMediaType, 0, 0);
        if(aMediaType == VideoMediaType) // We just want to check the video media samples.
        {
            SampleDescriptionHandle anImageDesc = NULL;
            anImageDesc = (SampleDescriptionHandle)NewHandle(sizeof(SampleDescription));
            DebugAssert(GetMemErr == noErr);

            GetMediaSampleDescription(aMedia, 1, anImageDesc);
            anErr = GetMoviesError(); DebugAssert(anErr == noErr);
            MoveHHi((Handle)anImageDesc); HLock((Handle)anImageDesc); // Really would not need to, but printf (don't trust that one
                                                                                                          // due to the MetroWerks Sioux environment).
            if(anErr != noErr)
            {
                DisposeHandle((Handle)anImageDesc);
                continue;
            }

            // OK, we have the Image Description, now present the values (see IM:QuickTime, page 3-50 for more
            // information about the ImageDescription structure).

            printf("The video track has a pixel depth of %d.\n", (*(ImageDescriptionHandle)anImageDesc)->depth);

            // Get the image description height and width values, test if these are multiple of 4 (if not there's a performance penalty).
            {
            long rest;

            printf("The video track has a source image height of %d.\n", (*(ImageDescriptionHandle)anImageDesc)->height);

            rest  = (*(ImageDescriptionHandle)anImageDesc)->height % 4;
            if (rest != 0)
                printf("NOTE! The source image height is not a multiple of 4, this means a performance hit.\n");

            printf("The video track has a source image width of %d.\n", (*(ImageDescriptionHandle)anImageDesc)->width);

            rest  = (*(ImageDescriptionHandle)anImageDesc)->width % 4;
            if (rest != 0)
                printf("NOTE! The source image width is not a multiple of 4, this means a performance hit.\n");
            }

            printf("The video track has a horizontal resolution of %ld.\n", Fix2Long( (*(ImageDescriptionHandle)anImageDesc)->hRes) );
            printf("The video track has a vertical resolution of %ld.\n", Fix2Long( (*(ImageDescriptionHandle)anImageDesc)->vRes) );

            printf("The codec used to compress the video samples:  %s\n", p2cstr( (*(ImageDescriptionHandle)anImageDesc)->name) );
            printf("Note that this is the codec for the first video sample, the video samples in the movie might have various codecs used...\n");
            {
                Byte *bp = (Byte *)&(*(ImageDescriptionHandle)anImageDesc)->vendor;
                printf("The video track was compressed by codec provided by '%c%c%c%c'.\n", bp[0], bp[1], bp[2], bp[3]);
            }
            printf("The temporal compression setting is %ld\n",  (*(ImageDescriptionHandle)anImageDesc)->temporalQuality);
            printf("The spatial compression setting is %ld\n",  (*(ImageDescriptionHandle)anImageDesc)->spatialQuality);


            printf("The image description structure is %ld bytes in size.\n",
                            (*(ImageDescriptionHandle)anImageDesc)->idSize);

            DisposeHandle((Handle)anImageDesc);
        }
    }
}


// ______________________________________________________________________
void ShowMovieSoundInfo(Movie theMovie)
{
    Str255     tmpStr;
    short        trackCount, index;
    OSErr        anErr = noErr;

    DebugAssert(aMovie != NULL);

    GetWTitle(FrontWindow(), tmpStr);
    printf("\nSound Media Information for %s:\n", p2cstr(tmpStr));

#ifdef THIS_WILL_TAKE_LONG
    printf("The movie has %d sound samples (samples)\n", QTUCountMediaSamples(theMovie, SoundMediaType));
#endif // THIS_WILL_TAKE_LONG

    // Get the sound description handle and munch it:
    trackCount = GetMovieTrackCount(theMovie);

    for(index = 1; index <= trackCount; index++)
    {
        Track        aTrack = NULL;
        Media        aMedia = NULL;
        OSType    aMediaType;

        aTrack = GetMovieIndTrack(theMovie, index); DebugAssert(aTrack != NULL);
        aMedia = GetTrackMedia(aTrack); DebugAssert(aMedia != NULL);
        anErr = GetMoviesError(); DebugAssert(anErr == noErr);
        if(anErr != noErr)
        {
            printf("Problems with getting trackmedia = %d\n", anErr);
            return;
        }

        GetMediaHandlerDescription(aMedia, &aMediaType, 0, 0);
        if(aMediaType == SoundMediaType)        // We just want to check out the sound description handles.
        {
            SampleDescriptionHandle aDesc = NULL;
            aDesc = (SampleDescriptionHandle)NewHandle(sizeof(SampleDescription));
            DebugAssert(GetMemErr() == noErr);

            GetMediaSampleDescription(aMedia, 1, aDesc);
            anErr = GetMoviesError(); DebugAssert(anErr == noErr);
            MoveHHi((Handle)aDesc); HLock((Handle)aDesc); // Really would not need to, but printf (don't trust that one
                                                                                     // due to the MetroWerks Sioux environment).
            if(anErr != noErr)
            {
                DisposeHandle((Handle)aDesc);
                continue;
            }
            // OK, we have the sound description handle now, present the values
            printf("The sound track rate is %d Hz.\n", (*(SoundDescriptionHandle)aDesc)->sampleRate >> 16);
            {
            long soundRate =  (*(SoundDescriptionHandle)aDesc)->sampleRate >> 16;
            if (soundRate < 30000)
                if( (soundRate != 22050) && (soundRate != 11025) )
                    printf("NOTE! The movie has a sound rate that will maybe cause performance problems with certain PC sound boards. If possible use 22050 or 11025 kHz instead\n");
            }

            printf("The sound track size is %d bit.\n", (*(SoundDescriptionHandle)aDesc)->sampleSize);

            printf("The sound track has %d channel(s).\n", (*(SoundDescriptionHandle)aDesc)->numChannels);
            {
                Byte *bp = (Byte *)&(*(SoundDescriptionHandle)aDesc)->dataFormat;
                printf("The sound track has the '%c%c%c%c' format.\n", bp[0], bp[1], bp[2], bp[3]);
            }

            printf("The sound description structure is %ld bytes in size.\n",
                            (*(SoundDescriptionHandle)aDesc)->descSize);
        }
    }
}


// ______________________________________________________________________
// This is a variation function of the QTUCountMediaSamples one, we want to figure out how
// many key frames we have in the movie.

pascal long QTUCountKeySamples(Movie theMovie, OSType theMediaType)
{
    long numFrames = 0;

    short flags = nextTimeEdgeOK + nextTimeSyncSample;
    TimeValue aDuration = 0;
    TimeValue theTime = 0;

    GetMovieNextInterestingTime(theMovie, flags, 1, &theMediaType, theTime, 0, &theTime, &aDuration);
    if(theTime == -1) return numFrames;

    flags = nextTimeSyncSample; // Don't include the  nudge after the first interesting time.

    while(theTime != -1)  // When the returned time equals -1, then there were no more interesting times.
    {
        numFrames++;
        GetMovieNextInterestingTime(theMovie, flags, 1, &theMediaType, theTime, 0, &theTime, &aDuration);
    }

    return numFrames;
}